package pc

import (
	. "chess_platform/internal/common"
	"chess_platform/models/pc"
	"fmt"
	"time"
)

//[pc]帐户管理
type UserController struct {
	GrantController
}

func (b *UserController) URLMapping() {
	//user:帐户列表
	b.Mapping("NewUser", b.NewUser)
	b.Mapping("UpdateUser", b.UpdateUser)
	b.Mapping("DisableUser", b.DisableUser)
	b.Mapping("UserInfo", b.UserInfo)
	b.Mapping("ListUser", b.ListUser)
	b.Mapping("ListUserGroup", b.ListUserGroup)
	b.Mapping("ListUserRole", b.ListUserRole)

	//role:角色列表
	b.Mapping("NewRole", b.NewRole)
	b.Mapping("UpdateRole", b.UpdateRole)
	b.Mapping("DeleteRole", b.DeleteRole)
	b.Mapping("RoleInfo", b.RoleInfo)
	b.Mapping("ListRole", b.ListRole)
	b.Mapping("ListPermissionMenu", b.ListPermissionMenu)

	//group:区域列表
	b.Mapping("NewGroup", b.NewGroup)
	b.Mapping("UpdateGroup", b.UpdateGroup)
	b.Mapping("UpdateGroupBonusRate", b.UpdateGroupBonusRate)
	b.Mapping("DeleteGroup", b.DeleteGroup)
	b.Mapping("ListGroup", b.ListGroup)

	//menu:左树菜单
	b.Mapping("NewMenu", b.NewMenu)
	b.Mapping("UpdateMenu", b.UpdateMenu)
	b.Mapping("DeleteMenu", b.DeleteMenu)
	b.Mapping("ListMenu", b.ListMenu)

}

// @Title 创建用户
// @Description 创建用户
// @Param   name     	body    string  true      "用户名"
// @Param   real_name   body    string  true      "真实名字"
// @Param   email    	body    string  false     "邮箱"
// @Param   password 	body    string  true      "密码"
// @Param   role_id  	body    int     true      "角色id"
// @Param   group_id 	body    int     true      "所属大区的id,0-公司,不属于任何大区,调用list-group获得"
// @Success 0 {string} 状态码
// @Failure 399
// @router /user/new-user [post]
func (b *UserController) NewUser() {
	var p PcUser
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.Name, "name").Message("用户名不能为空")
	b.Valid.Required(p.RealName, "real_name").Message("真实名字不能为空")
	b.Valid.MinSize(p.RealName, 2, "real_name").Message("真实名字长度为2-12个字符")
	b.Valid.MaxSize(p.RealName, 12, "real_name").Message("真实名字长度为2-12个字符")
	b.Valid.MinSize(p.Name, 3, "name").Message("用户名长度为3-12个字符")
	b.Valid.MaxSize(p.Name, 12, "name").Message("用户名长度为3-12个字符")
	b.Valid.AlphaDash(p.Name, "name").Message("用户名只支持字符为0-9a-zA-Z_-")
	b.Valid.Required(p.Password, "password").Message("密码不能为空")
	b.Valid.MinSize(p.Password, 6, "password").Message("密码长度为6-15个字符")
	b.Valid.MaxSize(p.Password, 15, "password").Message("密码长度为6-15个字符")
	b.Valid.Required(p.RoleId, "role_id").Message("请选择角色")
	b.Valid.Min(p.GroupId, 0, "group_id").Message("请选择一个所属区域")
	if p.Email != "" {
		b.Valid.Email(p.Email, "email").Message("请输入正确的邮箱")
	}
	if !b.VerifyParamsError() {
		return
	}
	//只有超级管理员才能有权选择系统内置角色
	if !b.IsSystemAdmin() {
		role, err := pc.RoleInfoById(p.RoleId)
		if err != nil {
			LogPc.Error(b.DatabaseError(err.Error()))
			return
		}
		if role == nil {
			b.ResponseFail("所选角色不存在")
			return
		}
		if role.Mutable == 0 {
			b.ResponseFail("您不能选择系统内置角色")
			return
		}

	}

	_, ok := pc.IsUserExist(p.Name)
	if ok {
		b.Res.Code = ErrUserAlreadyExist
		b.Res.Msg = MsgErrUserAlreadyExist
		b.Response()
		return
	}

	p.Password = Md5sum(p.Password)
	user := map[string]interface{}{
		"name":        p.Name,
		"real_name":   p.RealName,
		"password":    p.Password,
		"role_id":     p.RoleId,
		"email":       p.Email,
		"group_id":    p.GroupId,
		"mutable":     1, //非系统内置的用户是可以删除的
		"create_time": time.Now().Unix(),
	}
	_, err := pc.NewUser(user)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}

	b.ResponseSuccess()
	msg := fmt.Sprintf("创建用户")
	b.NewLog(LogPcUser, OpNew, msg, user)
}

// @Title 更新用户
// @Description 更新用户
// @Param   uid       	body    int     true      "用户id"
// @Param   real_name   body    string  true      "真实名字"
// @Param   email    	body    string  true      "邮件"
// @Param   password 	body    string  true      "密码"
// @Param   role_id  	body    int     true      "角色id"
// @Param   group_id 	body    int     true      "所属大区的id,不属于任何大区,调用list-group获得"
// @Success 0 {string} 状态码
// @Failure 399
// @router /user/update-user [post]
func (b *UserController) UpdateUser() {
	var p PcUser
	if !b.DecodeParams(&p) {
		return
	}

	b.Valid.Required(p.Uid, "uid").Message("用户Id不能为零")
	b.Valid.Required(p.RoleId, "role_id").Message("请选择角色")
	if p.Password != "" {
		b.Valid.MinSize(p.Password, 6, "password").Message("密码长度为6-15个字符")
		b.Valid.MaxSize(p.Password, 15, "password").Message("密码长度为6-15个字符")
	}
	if p.Email != "" {
		b.Valid.Email(p.Email, "email").Message("请输入正确的邮箱")
	}
	b.Valid.Min(p.GroupId, 0, "group_id").Message("请选择一个所属区域")
	if !b.VerifyParamsError() {
		return
	}

	editUser, err := pc.UserInfoById(p.Uid)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}

	switch {
	case b.IsSystemAdmin() && p.Uid == b.Uid: //系统管理员自己修改自己的信息
		LogPc.Info("系统管理员自己修改自己的信息")
		if p.RoleId != editUser.RoleId {
			b.ResponseFail("系统内置账号,角色不可编辑")
			return
		}
		if p.GroupId != editUser.GroupId {
			b.ResponseFail("系统内置账号,所属区域不可编辑")
			return
		}
	case b.IsSystemAdmin() && p.Uid != b.Uid: //系统管理员修改其它所有的帐号
		LogPc.Info("系统管理员修改其它所有的帐号")

	case b.IsSpecialAdmin() && p.Uid == b.Uid: //公司管理员修改自己的信息
		LogPc.Info("公司管理员修改自己的信息")
		if p.RoleId != editUser.RoleId {
			b.ResponseFail("角色不可编辑,如需修改请联系上级管理员")
			return
		}
		if p.GroupId != editUser.GroupId {
			b.ResponseFail("所属区域不可编辑,如需修改请联系上级管理员")
			return
		}
		if p.RealName != editUser.RealName {
			b.ResponseFail("真实名字不可修改,如需修改请联系上级管理员")
			return
		}
	case b.IsSpecialAdmin() && p.Uid != b.Uid: //公司管理员修改其它所有的帐号,除了系统管理员和其它公司管理员
		if b.IsAdmin(p.Uid) {
			b.ResponseFail("您无权修改其它管理员或开发者的信息")
			return
		}
	case b.IsOrdinaryUser() && p.Uid == b.Uid: //普通账号
		LogPc.Info("普通账号自己修改自己的信息")
		if p.RoleId != editUser.RoleId {
			b.ResponseFail("角色不可更改,如需修改请联系上级管理员")
			return
		}
		if p.GroupId != editUser.GroupId {
			b.ResponseFail("所属区域不可更改,如需修改请联系上级管理员")
			return
		}
		if p.RealName != editUser.RealName {
			b.ResponseFail("真实名字不可修改,如需修改请联系上级管理员")
			return
		}
	case b.IsOrdinaryUser() && p.Uid != b.Uid:
		b.ResponseFail("您无权修改他人的账号信息")
		return
	default:
		b.ResponseFail("您无权限操作")
		return

	}

	user := map[string]interface{}{
		"real_name": p.RealName,
		"role_id":   p.RoleId,
		"email":     p.Email,
		"group_id":  p.GroupId,
	}
	if p.Password != "" {
		user["password"] = Md5sum(p.Password)
	}
	_, err = pc.UpdateUser(user, p.Uid)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))

		return
	}

	b.ResponseSuccess()
	msg := fmt.Sprintf("更新平台管理用户(ID:%v)", p.Uid)
	b.NewLog(LogPcUser, OpUpdate, msg, user)
}

// @Title 冻结用户
// @Description 冻结用户
// @Param   uid     body    int     true      "用户id"
// @Param   frozen  body    int     true      "1-冻结,0-解冻"
// @Success 0 {string} 状态码
// @router /user/disable-user [post]
func (b *UserController) DisableUser() {
	type Params struct {
		Uid    int64 `json:"uid"`
		Frozen int64 `json:"frozen" valid:"Range(0,1)"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}

	switch {
	case b.IsSystemAdmin() && p.Uid == b.Uid: //系统管理员不能冻结解冻自己
		LogPc.Info("系统管理员不能冻结解冻自己")
		b.ResponseFail("系统管理员不能冻结解冻自己")
		return
	case b.IsSystemAdmin() && p.Uid != b.Uid: //系统管理员冻结解冻其它所有的帐号
		LogPc.Info("系统管理员冻结解冻其它所有的帐号")
		/*
			case b.IsCompanyAdmin() && p.Uid == b.Uid: //公司管理员修改自己的信息
				LogPc.Info("公司管理员不能冻结解冻自己")
				b.ResponseFail("公司管理员不能冻结解冻自己")
				return
			case b.IsCompanyAdmin() && p.Uid != b.Uid: //公司管理员冻结解冻其它所有的帐号,除了系统管理员和其它公司管理员
				if b.IsAdmin(p.Uid) {
					b.ResponseFail("您无权冻结解冻其它管理员")
					return
				}
		*/
	default: //普通账号
		if p.Uid == b.Uid {
			b.ResponseFail("不能冻结解冻自己")
			return
		}

	}

	user := map[string]interface{}{
		"frozen": p.Frozen,
	}
	_, err := pc.UpdateUser(user, p.Uid)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))

		return
	}
	b.ResponseSuccess()
	var msg string
	if p.Frozen == 0 {
		msg = fmt.Sprintf("解冻平台管理用户(ID:%v)", p.Uid)
	} else {
		msg = fmt.Sprintf("冻结平台管理用户(ID:%v)", p.Uid)
	}
	b.NewLog(LogPcUser, OpUpdate, msg, map[string]interface{}{})
}

// @Title 用户详情
// @Description 用户详情
// @Param   uid  body    int     true      "用户uid"
// @Success 0 {object} common.PcUser 用户信息
// @router /user/user-info [post]
func (b *UserController) UserInfo() {
	type Params struct {
		Uid int64 `json:"uid" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	user, err := pc.UserInfoById(p.Uid)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))

		return
	}
	b.Res.Data = user
	b.ResponseSuccess()
}

// @Title 获取用户列表
// @Description 获取用户列表
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Param   name         body   string  false      "搜索用户名字"
// @Success 0 {object} []common.PcUser 用户列表
// @router /user/list-user [post]
func (b *UserController) ListUser() {
	var p ListPcUserParams
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	users, count, err := pc.ListUserInfo(p)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}

	b.Res.Data = users
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 获取大区列表
// @Description 获取大区列表
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Success 0 {object} []common.Group 代理用户列表
// @router /user/list-group [post]
func (b *UserController) ListUserGroup() {
	var p ListParams
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data, count, err := pc.ListGroup(p)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))

		return
	}

	b.Res.Data = data
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 获取角色列表
// @Description 获取角色列表
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Param   name         body   string  false      "搜索角色名字"
// @Success 0 {object} []common.Role   角色列表
// @router /user/list-role [post]
func (b *UserController) ListUserRole() {
	type Params struct {
		ListParams
		Name string `json:"name"`
	}

	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data, count, err := pc.ListRole(p.ListParams, p.Name, b.IsSystemAdmin())
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}

	b.Res.Data = data
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 创建角色
// @Description 创建角色
// @Param   name     		body    string     true      "角色名"
// @Param   menu            body    string     true      "menu id数组字符串形式 "[1,2,3]" "
// @Success 0 {string} 状态码
// @Failure 399
// @router /role/new-role [post]
func (b *UserController) NewRole() {
	if !b.IsSystemAdmin() {
		b.ResponseFail("您无权限")
		return
	}
	type Params struct {
		Name string `json:"name"`
		Menu string `json:"menu"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}

	b.Valid.Required(p.Name, "name").Message("角色名不能为空")
	b.Valid.MinSize(p.Name, 1, "name").Message("角色名长度为1-12个字符")
	b.Valid.MaxSize(p.Name, 12, "name").Message("角色名长度为1-12个字符")
	b.Valid.MinSize(p.Menu, 1, "menu").Message("权限不能为空")
	if !b.VerifyParamsError() {
		return
	}

	_, ok := pc.IsRoleExistByName(p.Name)
	if ok {
		b.Res.Code = ErrRoleAlreadyExist
		b.Res.Msg = MsgErrRoleAlreadyExist
		b.Response()
		return
	}
	role := map[string]interface{}{
		"name":        p.Name,
		"creator_id":  b.Uid,
		"create_time": time.Now().Unix(),
		"mutable":     1, //不是内置的角色都是可修改可删除的
		"menu":        p.Menu,
	}
	_, err := pc.NewRole(role)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	b.NewLog(LogPcUser, OpNew, "新建平台管理角色", role)
}

// @Title 更新角色
// @Description 更新角色
// @Param   id              body    int     true      "角色id"
// @Param   name     		body    string  true      "角色名"
// @Param   menu            body    string  true      "menu id数组字符串形式 "[1,2,3]" "
// @Success 0 {string} 状态码
// @Failure 399
// @router /role/update-role [post]
func (b *UserController) UpdateRole() {
	if !b.IsSystemAdmin() {
		b.ResponseFail("您无权限")
		return
	}
	type Params struct {
		Id   int64  `json:"id" valid:"Required"`
		Name string `json:"name"`
		Menu string `json:"menu"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.Name, "name").Message("角色名不能为空")
	b.Valid.MinSize(p.Name, 1, "name").Message("角色名长度为1-12个字符")
	b.Valid.MaxSize(p.Name, 12, "name").Message("角色名长度为1-12个字符")
	b.Valid.MinSize(p.Menu, 1, "menu").Message("权限不能为空")
	if !b.ValidParams(&p) {
		return
	}

	r, ok := pc.IsRoleExistByName(p.Name)
	if ok && r.Id != p.Id {
		b.Res.Code = ErrRoleAlreadyExist
		b.Res.Msg = MsgErrRoleAlreadyExist
		b.Response()
		return
	}
	role := map[string]interface{}{
		"name": p.Name,
		"menu": p.Menu,
	}

	err := pc.UpdateRole(role, p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	//更新完角色之后要把此角色对应的url也更新到cache里
	pc.UpdateRoleMenuToCache(p.Id)
	msg := fmt.Sprintf("更新平台管理角色(ID:%v)", p.Id)
	b.NewLog(LogPcUser, OpUpdate, msg, role)
}

// @Title 删除角色
// @Description 删除角色
// @Param   id  body    int     true      "角色id"
// @Success 0 {string} 状态码
// @router /role/delete-role [post]
func (b *UserController) DeleteRole() {
	if !b.IsSystemAdmin() {
		b.ResponseFail("您无权限")
		return
	}
	type Params struct {
		Id int64 `json:"id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	r, ok := pc.IsRoleExistById(p.Id)
	if ok && r.Mutable == 0 {
		b.ResponseFail("系统内置角色,不可删除")
		return
	}
	err := pc.DeleteRole(p.Id)
	if err == MsgErrRoleAlreadyBind {
		b.Res.Code = Fail
		b.Res.Msg = MsgErrRoleAlreadyBind.Error()
		b.Response()
		return
	}
	//走到这里，肯定不是上面的错误了
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()

	msg := fmt.Sprintf("删除平台管理角色(ID:%v)", p.Id)
	b.NewLog(LogPcUser, OpDelete, msg, map[string]interface{}{})
}

// @Title 获取角色信息(包括权限详细信息)
// @Description 获取角色信息(包括权限详细信息)
// @Param   id  body    int     true      "角色id"
// @Success 0 {object}  common.Role 角色信息
// @router /role/role-info [post]
func (b *UserController) RoleInfo() {
	if !b.IsSystemAdmin() {
		b.ResponseFail("您无权限")
		return
	}
	type Params struct {
		Id int64 `json:"id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	role, err := pc.RoleAuthorizedInfo(p.Id, false)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = role
	b.ResponseSuccess()
}

// @Title 获取角色列表
// @Description 获取角色列表
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Param   name         body   string  false      "搜索角色名字"
// @Success 0 {object} []common.Role   角色列表
// @router /role/list-role [post]
func (b *UserController) ListRole() {
	if !b.IsSystemAdmin() {
		b.ResponseFail("您无权限")
		return
	}
	type Params struct {
		ListParams
		Name string `json:"name"`
	}

	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data, count, err := pc.ListRole(p.ListParams, p.Name, b.IsSystemAdmin())
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}

	b.Res.Data = data
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 获取权限菜单列表
// @Description 获取权限菜单列表
// @Success 0 {object} common.Menu 获取权限列表
// @router /role/list-menu [post]
func (b *UserController) ListPermissionMenu() {
	if !b.IsSystemAdmin() {
		b.ResponseFail("您无权限")
		return
	}
	parent, child, err := pc.ListMenu()
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = pc.MergeMenu(parent, child)
	b.ResponseSuccess()
}

// @Title 新建大区
// @Description 新建大区
// @Param   name           body    string  true      "大区名"
// @Success 0 {string} 状态码
// @Failure 399
// @router /group/new-group [post]
func (b *UserController) NewGroup() {
	var p Group
	if !b.DecodeParams(&p) {
		return
	}

	b.Valid.Required(p.Name, "name").Message("大区不能为空")
	if !b.VerifyParamsError() {
		return
	}

	if _, ok := pc.IsGroupExist(p.Name); ok {
		b.Res.Code = ErrAlreadyExist
		b.Res.Msg = "大区已经存在"
		b.Response()
		return
	}

	data := map[string]interface{}{
		"name":        p.Name,
		"mutable":     1, //创建的都不是系统内置的，可以编辑删除
		"create_time": time.Now().Unix(),
	}
	_, err := pc.NewGroup(data)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}

	b.ResponseSuccess()
	msg := fmt.Sprintf("新建大区:%v", p.Name)
	b.NewLog(LogPcUser, OpNew, msg, map[string]interface{}{})
}

// @Title 更新大区名字
// @Description 更新大区名字
// @Param   id             body    int     true      "id"
// @Param   name           body    string  true      "大区名"
// @Success 0 {string} 状态码
// @Failure 399
// @router /group/update-group [post]
func (b *UserController) UpdateGroup() {
	var p Group
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.Id, "id").Message("id不能为零")
	b.Valid.Required(p.Name, "name").Message("大区名不能为空")
	if !b.VerifyParamsError() {
		return
	}
	group, err := pc.GroupInfoById(p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))

		return
	}
	if group == nil {
		b.ResponseFail("您更新的大区不存在")
		return
	}
	if group.Mutable == 0 {
		b.ResponseFail("系统内置大区,不可编辑")
		return
	}

	if id, ok := pc.IsGroupExist(p.Name); ok && id != p.Id {
		b.Res.Code = ErrAlreadyExist
		b.Res.Msg = "大区已经存在"
		b.Response()
		return
	}
	data := map[string]interface{}{
		"name": p.Name,
	}
	_, err = pc.UpdateGroup(data, p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}

	b.ResponseSuccess()
	msg := fmt.Sprintf("更新大区(ID:%v)名字为%v", p.Id, p.Name)
	b.NewLog(LogPcUser, OpUpdate, msg, map[string]interface{}{})
}

// @Title 更新大区提成比例
// @Description 更新大区提成比例
// @Param   id             body    int     true      "id"
// @Param   bonus_rate     body    int     true      "大区提成比例,展示时要除以10000,存时要乘以10000"
// @Success 0 {string} 状态码
// @Failure 399
// @router /group/update-group-bonus-rate [post]
func (b *UserController) UpdateGroupBonusRate() {
	var p Group
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.Id, "id").Message("id不能为零")
	if !b.VerifyParamsError() {
		return
	}

	data := map[string]interface{}{
		"bonus_rate": p.BonusRate,
	}
	_, err := pc.UpdateGroup(data, p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}

	b.ResponseSuccess()
	msg := fmt.Sprintf("更新大区(ID:%v)提成比例为%v", p.Id, p.BonusRate)
	b.NewLog(LogPcUser, OpUpdate, msg, map[string]interface{}{})
}

// @Title 删除大区
// @Description 删除大区
// @Param   id         body   int        true        "大区id"
// @Success 0 {string}  状态码
// @router /group/delete-group [post]
func (b *UserController) DeleteGroup() {
	type Params struct {
		Id int64 `json:"id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	g, err := pc.GroupInfoById(p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	if g == nil {
		b.ResponseFail("您删除的区域不存在")
		return
	}
	if g.Mutable == 0 {
		b.ResponseFail("系统内置区域,不能删除")
		return
	}
	if pc.IsGroupBind(p.Id) {
		b.ResponseFail("此大区已经被绑定了,不可删除")
		return
	}
	_, err = pc.DeleteGroup(p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	msg := fmt.Sprintf("删除大区(ID:%v)", p.Id)
	b.NewLog(LogPcUser, OpDelete, msg, map[string]interface{}{})
}

// @Title 获取大区列表
// @Description 获取大区列表
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Success 0 {object} []common.Group 代理用户列表
// @router /group/list-group [post]
func (b *UserController) ListGroup() {
	var p ListParams
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	data, count, err := pc.ListGroup(p)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}

	b.Res.Data = data
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 创建菜单
// @Description 创建菜单
// @Param   parent_id  		body    int     true      "父亲节点id(最外层的菜单时传0)"
// @Param   name     		body    string  true      "菜单名字"
// @Param   module_name     body    string  true      "模块名"
// @Param   url             body    string  true      "跳转链接"
// @Success 0 {string} 状态码
// @Failure 399
// @router /menu/new-menu [post]
func (b *UserController) NewMenu() {
	type Params struct {
		ParentId   int64  `json:"parent_id"`
		Name       string `json:"name"`
		ModuleName string `json:"module_name"`
		Url        string `json:"url"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.Name, "name").Message("名称不能为空")
	b.Valid.Required(p.ModuleName, "module_name").Message("模块名称不能为空")
	if !b.VerifyParamsError() {
		return
	}
	data := map[string]interface{}{
		"parent_id":   p.ParentId,
		"name":        p.Name,
		"module_name": p.ModuleName,
		"url":         p.Url,
	}
	_, err := pc.NewMenu(data)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}

	b.ResponseSuccess()
	b.NewLog(LogMenu, OpNew, "新建一个菜单树", data)
}

// @Title 更新左树菜单
// @Description 更新左树菜单
// @Param   id      		body    int     true      "id"
// @Param   parent_id  		body    int     true      "父亲节点id(最外层的菜单时传0)"
// @Param   name     		body    string  true      "菜单名字"
// @Param   module_name     body    string  true      "模块名字"
// @Param   url             body    string  true      "跳转链接"
// @Success 0 {string} 状态码
// @Failure 399
// @router /menu/update-menu [post]
func (b *UserController) UpdateMenu() {
	type Params struct {
		Id         int64  `json:"id"`
		ParentId   int64  `json:"parent_id"`
		Name       string `json:"name"`
		ModuleName string `json:"module_name"`
		Url        string `json:"url"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	b.Valid.Required(p.Id, "id").Message("Id不能为0")
	b.Valid.Required(p.Name, "name").Message("名称不能为空")
	b.Valid.Required(p.ModuleName, "module_name").Message("模块名称不能为空")
	//b.Valid.Required(p.Url, "url").Message("跳转链接名称不能为空")
	if !b.VerifyParamsError() {
		return
	}
	data := map[string]interface{}{
		"parent_id":   p.ParentId,
		"name":        p.Name,
		"module_name": p.ModuleName,
		"url":         p.Url,
	}
	_, err := pc.UpdateMenu(data, p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}

	b.ResponseSuccess()
	msg := fmt.Sprintf("更新一个菜单树(树ID:%v)", p.Id)
	b.NewLog(LogMenu, OpUpdate, msg, data)
}

// @Title 删除左树菜单
// @Description 删除左树菜单
// @Param   id      		body    int     true      "id"
// @Success 0 {string} 状态码
// @Failure 399
// @router /menu/delete-menu [post]
func (b *UserController) DeleteMenu() {
	type Params struct {
		Id int64 `json:"id" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}

	_, err := pc.DeleteMenu(p.Id)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	msg := fmt.Sprintf("删除一个菜单树(树ID:%v)", p.Id)
	b.NewLog(LogMenu, OpDelete, msg, map[string]interface{}{})
}

// @Title 获取左树菜单列表
// @Description 获取左树菜单列表
// @Success 0 {object} common.Permission 左树菜单列表
// @router /menu/list-menu [post]
func (b *UserController) ListMenu() {
	parent, child, err := pc.ListMenu()
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = pc.MergeMenu(parent, child)
	b.ResponseSuccess()
}
